/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Persistencia;

import java.io.Serializable;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import Logica.Empleado;
import java.util.ArrayList;
import java.util.List;
import Logica.Repuesto;
import java.util.HashSet;
import java.util.Set;
import Logica.Turno;
import Logica.ReparacionEnEjecucion;
import Logica.DiaLaboral;
import Logica.Proveedor;
import Logica.Taller;
import Persistencia.exceptions.NonexistentEntityException;
import Persistencia.exceptions.PreexistingEntityException;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

/**
 *
 * @author Pablo
 */
public class TallerJpaController implements Serializable {

    public TallerJpaController(){
        emf = Persistence.createEntityManagerFactory("TpFinalPU");
    }
    public TallerJpaController(EntityManagerFactory emf) {
        this.emf = emf;
    }
    private EntityManagerFactory emf = null;

    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public void create(Taller taller) throws PreexistingEntityException, Exception {
        if (taller.getEmpleados() == null) {
            taller.setEmpleados(new ArrayList<Empleado>());
        }
        if (taller.getRepuestos() == null) {
            taller.setRepuestos(new HashSet<Repuesto>());
        }
        if (taller.getTurnos() == null) {
            taller.setTurnos(new ArrayList<Turno>());
        }
        if (taller.getReparacionesEnEjecucion() == null) {
            taller.setReparacionesEnEjecucion(new ArrayList<ReparacionEnEjecucion>());
        }
        if (taller.getDiasLaborables() == null) {
            taller.setDiasLaborables(new ArrayList<DiaLaboral>());
        }
        if (taller.getProveedores() == null) {
            taller.setProveedores(new ArrayList<Proveedor>());
        }
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            List<Empleado> attachedEmpleados = new ArrayList<Empleado>();
            for (Empleado empleadosEmpleadoToAttach : taller.getEmpleados()) {
                empleadosEmpleadoToAttach = em.getReference(empleadosEmpleadoToAttach.getClass(), empleadosEmpleadoToAttach.getNroDoc());
                attachedEmpleados.add(empleadosEmpleadoToAttach);
            }
            taller.setEmpleados(attachedEmpleados);
            Set<Repuesto> attachedRepuestos = new HashSet<Repuesto>();
            for (Repuesto repuestosRepuestoToAttach : taller.getRepuestos()) {
                repuestosRepuestoToAttach = em.getReference(repuestosRepuestoToAttach.getClass(), repuestosRepuestoToAttach.getCodigo());
                attachedRepuestos.add(repuestosRepuestoToAttach);
            }
            taller.setRepuestos(attachedRepuestos);
            List<Turno> attachedTurnos = new ArrayList<Turno>();
            for (Turno turnosTurnoToAttach : taller.getTurnos()) {
                turnosTurnoToAttach = em.getReference(turnosTurnoToAttach.getClass(), turnosTurnoToAttach.getNroTurno());
                attachedTurnos.add(turnosTurnoToAttach);
            }
            taller.setTurnos(attachedTurnos);
            List<ReparacionEnEjecucion> attachedReparacionesEnEjecucion = new ArrayList<ReparacionEnEjecucion>();
            for (ReparacionEnEjecucion reparacionesEnEjecucionReparacionEnEjecucionToAttach : taller.getReparacionesEnEjecucion()) {
                reparacionesEnEjecucionReparacionEnEjecucionToAttach = em.getReference(reparacionesEnEjecucionReparacionEnEjecucionToAttach.getClass(), reparacionesEnEjecucionReparacionEnEjecucionToAttach.getNroReparacionEnEjecucion());
                attachedReparacionesEnEjecucion.add(reparacionesEnEjecucionReparacionEnEjecucionToAttach);
            }
            taller.setReparacionesEnEjecucion(attachedReparacionesEnEjecucion);
            List<DiaLaboral> attachedDiasLaborables = new ArrayList<DiaLaboral>();
            for (DiaLaboral diasLaborablesDiaLaboralToAttach : taller.getDiasLaborables()) {
                diasLaborablesDiaLaboralToAttach = em.getReference(diasLaborablesDiaLaboralToAttach.getClass(), diasLaborablesDiaLaboralToAttach.getFecha());
                attachedDiasLaborables.add(diasLaborablesDiaLaboralToAttach);
            }
            taller.setDiasLaborables(attachedDiasLaborables);
            List<Proveedor> attachedProveedores = new ArrayList<Proveedor>();
            for (Proveedor proveedoresProveedorToAttach : taller.getProveedores()) {
                proveedoresProveedorToAttach = em.getReference(proveedoresProveedorToAttach.getClass(), proveedoresProveedorToAttach.getRazonSocial());
                attachedProveedores.add(proveedoresProveedorToAttach);
            }
            taller.setProveedores(attachedProveedores);
            em.persist(taller);
            for (Empleado empleadosEmpleado : taller.getEmpleados()) {
                Taller oldUnTallerOfEmpleadosEmpleado = empleadosEmpleado.getUnTaller();
                empleadosEmpleado.setUnTaller(taller);
                empleadosEmpleado = em.merge(empleadosEmpleado);
                if (oldUnTallerOfEmpleadosEmpleado != null) {
                    oldUnTallerOfEmpleadosEmpleado.getEmpleados().remove(empleadosEmpleado);
                    oldUnTallerOfEmpleadosEmpleado = em.merge(oldUnTallerOfEmpleadosEmpleado);
                }
            }
            for (Repuesto repuestosRepuesto : taller.getRepuestos()) {
                Taller oldUnTallerOfRepuestosRepuesto = repuestosRepuesto.getUnTaller();
                repuestosRepuesto.setUnTaller(taller);
                repuestosRepuesto = em.merge(repuestosRepuesto);
                if (oldUnTallerOfRepuestosRepuesto != null) {
                    oldUnTallerOfRepuestosRepuesto.getRepuestos().remove(repuestosRepuesto);
                    oldUnTallerOfRepuestosRepuesto = em.merge(oldUnTallerOfRepuestosRepuesto);
                }
            }
            for (Turno turnosTurno : taller.getTurnos()) {
                Taller oldUnTallerOfTurnosTurno = turnosTurno.getUnTaller();
                turnosTurno.setUnTaller(taller);
                turnosTurno = em.merge(turnosTurno);
                if (oldUnTallerOfTurnosTurno != null) {
                    oldUnTallerOfTurnosTurno.getTurnos().remove(turnosTurno);
                    oldUnTallerOfTurnosTurno = em.merge(oldUnTallerOfTurnosTurno);
                }
            }
            for (ReparacionEnEjecucion reparacionesEnEjecucionReparacionEnEjecucion : taller.getReparacionesEnEjecucion()) {
                Taller oldUnTallerOfReparacionesEnEjecucionReparacionEnEjecucion = reparacionesEnEjecucionReparacionEnEjecucion.getUnTaller();
                reparacionesEnEjecucionReparacionEnEjecucion.setUnTaller(taller);
                reparacionesEnEjecucionReparacionEnEjecucion = em.merge(reparacionesEnEjecucionReparacionEnEjecucion);
                if (oldUnTallerOfReparacionesEnEjecucionReparacionEnEjecucion != null) {
                    oldUnTallerOfReparacionesEnEjecucionReparacionEnEjecucion.getReparacionesEnEjecucion().remove(reparacionesEnEjecucionReparacionEnEjecucion);
                    oldUnTallerOfReparacionesEnEjecucionReparacionEnEjecucion = em.merge(oldUnTallerOfReparacionesEnEjecucionReparacionEnEjecucion);
                }
            }
            for (DiaLaboral diasLaborablesDiaLaboral : taller.getDiasLaborables()) {
                Taller oldUnTallerOfDiasLaborablesDiaLaboral = diasLaborablesDiaLaboral.getUnTaller();
                diasLaborablesDiaLaboral.setUnTaller(taller);
                diasLaborablesDiaLaboral = em.merge(diasLaborablesDiaLaboral);
                if (oldUnTallerOfDiasLaborablesDiaLaboral != null) {
                    oldUnTallerOfDiasLaborablesDiaLaboral.getDiasLaborables().remove(diasLaborablesDiaLaboral);
                    oldUnTallerOfDiasLaborablesDiaLaboral = em.merge(oldUnTallerOfDiasLaborablesDiaLaboral);
                }
            }
            for (Proveedor proveedoresProveedor : taller.getProveedores()) {
                Taller oldUnTallerOfProveedoresProveedor = proveedoresProveedor.getUnTaller();
                proveedoresProveedor.setUnTaller(taller);
                proveedoresProveedor = em.merge(proveedoresProveedor);
                if (oldUnTallerOfProveedoresProveedor != null) {
                    oldUnTallerOfProveedoresProveedor.getProveedores().remove(proveedoresProveedor);
                    oldUnTallerOfProveedoresProveedor = em.merge(oldUnTallerOfProveedoresProveedor);
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            if (findTaller(taller.getNroTaller()) != null) {
                throw new PreexistingEntityException("Taller " + taller + " already exists.", ex);
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(Taller taller) throws NonexistentEntityException, Exception {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Taller persistentTaller = em.find(Taller.class, taller.getNroTaller());
            List<Empleado> empleadosOld = persistentTaller.getEmpleados();
            List<Empleado> empleadosNew = taller.getEmpleados();
            Set<Repuesto> repuestosOld = persistentTaller.getRepuestos();
            Set<Repuesto> repuestosNew = taller.getRepuestos();
            List<Turno> turnosOld = persistentTaller.getTurnos();
            List<Turno> turnosNew = taller.getTurnos();
            List<ReparacionEnEjecucion> reparacionesEnEjecucionOld = persistentTaller.getReparacionesEnEjecucion();
            List<ReparacionEnEjecucion> reparacionesEnEjecucionNew = taller.getReparacionesEnEjecucion();
            List<DiaLaboral> diasLaborablesOld = persistentTaller.getDiasLaborables();
            List<DiaLaboral> diasLaborablesNew = taller.getDiasLaborables();
            List<Proveedor> proveedoresOld = persistentTaller.getProveedores();
            List<Proveedor> proveedoresNew = taller.getProveedores();
            List<Empleado> attachedEmpleadosNew = new ArrayList<Empleado>();
            for (Empleado empleadosNewEmpleadoToAttach : empleadosNew) {
                empleadosNewEmpleadoToAttach = em.getReference(empleadosNewEmpleadoToAttach.getClass(), empleadosNewEmpleadoToAttach.getNroDoc());
                attachedEmpleadosNew.add(empleadosNewEmpleadoToAttach);
            }
            empleadosNew = attachedEmpleadosNew;
            taller.setEmpleados(empleadosNew);
            Set<Repuesto> attachedRepuestosNew = new HashSet<Repuesto>();
            for (Repuesto repuestosNewRepuestoToAttach : repuestosNew) {
                repuestosNewRepuestoToAttach = em.getReference(repuestosNewRepuestoToAttach.getClass(), repuestosNewRepuestoToAttach.getCodigo());
                attachedRepuestosNew.add(repuestosNewRepuestoToAttach);
            }
            repuestosNew = attachedRepuestosNew;
            taller.setRepuestos(repuestosNew);
            List<Turno> attachedTurnosNew = new ArrayList<Turno>();
            for (Turno turnosNewTurnoToAttach : turnosNew) {
                turnosNewTurnoToAttach = em.getReference(turnosNewTurnoToAttach.getClass(), turnosNewTurnoToAttach.getNroTurno());
                attachedTurnosNew.add(turnosNewTurnoToAttach);
            }
            turnosNew = attachedTurnosNew;
            taller.setTurnos(turnosNew);
            List<ReparacionEnEjecucion> attachedReparacionesEnEjecucionNew = new ArrayList<ReparacionEnEjecucion>();
            for (ReparacionEnEjecucion reparacionesEnEjecucionNewReparacionEnEjecucionToAttach : reparacionesEnEjecucionNew) {
                reparacionesEnEjecucionNewReparacionEnEjecucionToAttach = em.getReference(reparacionesEnEjecucionNewReparacionEnEjecucionToAttach.getClass(), reparacionesEnEjecucionNewReparacionEnEjecucionToAttach.getNroReparacionEnEjecucion());
                attachedReparacionesEnEjecucionNew.add(reparacionesEnEjecucionNewReparacionEnEjecucionToAttach);
            }
            reparacionesEnEjecucionNew = attachedReparacionesEnEjecucionNew;
            taller.setReparacionesEnEjecucion(reparacionesEnEjecucionNew);
            List<DiaLaboral> attachedDiasLaborablesNew = new ArrayList<DiaLaboral>();
            for (DiaLaboral diasLaborablesNewDiaLaboralToAttach : diasLaborablesNew) {
                diasLaborablesNewDiaLaboralToAttach = em.getReference(diasLaborablesNewDiaLaboralToAttach.getClass(), diasLaborablesNewDiaLaboralToAttach.getFecha());
                attachedDiasLaborablesNew.add(diasLaborablesNewDiaLaboralToAttach);
            }
            diasLaborablesNew = attachedDiasLaborablesNew;
            taller.setDiasLaborables(diasLaborablesNew);
            List<Proveedor> attachedProveedoresNew = new ArrayList<Proveedor>();
            for (Proveedor proveedoresNewProveedorToAttach : proveedoresNew) {
                proveedoresNewProveedorToAttach = em.getReference(proveedoresNewProveedorToAttach.getClass(), proveedoresNewProveedorToAttach.getRazonSocial());
                attachedProveedoresNew.add(proveedoresNewProveedorToAttach);
            }
            proveedoresNew = attachedProveedoresNew;
            taller.setProveedores(proveedoresNew);
            taller = em.merge(taller);
            for (Empleado empleadosOldEmpleado : empleadosOld) {
                if (!empleadosNew.contains(empleadosOldEmpleado)) {
                    empleadosOldEmpleado.setUnTaller(null);
                    empleadosOldEmpleado = em.merge(empleadosOldEmpleado);
                }
            }
            for (Empleado empleadosNewEmpleado : empleadosNew) {
                if (!empleadosOld.contains(empleadosNewEmpleado)) {
                    Taller oldUnTallerOfEmpleadosNewEmpleado = empleadosNewEmpleado.getUnTaller();
                    empleadosNewEmpleado.setUnTaller(taller);
                    empleadosNewEmpleado = em.merge(empleadosNewEmpleado);
                    if (oldUnTallerOfEmpleadosNewEmpleado != null && !oldUnTallerOfEmpleadosNewEmpleado.equals(taller)) {
                        oldUnTallerOfEmpleadosNewEmpleado.getEmpleados().remove(empleadosNewEmpleado);
                        oldUnTallerOfEmpleadosNewEmpleado = em.merge(oldUnTallerOfEmpleadosNewEmpleado);
                    }
                }
            }
            for (Repuesto repuestosOldRepuesto : repuestosOld) {
                if (!repuestosNew.contains(repuestosOldRepuesto)) {
                    repuestosOldRepuesto.setUnTaller(null);
                    repuestosOldRepuesto = em.merge(repuestosOldRepuesto);
                }
            }
            for (Repuesto repuestosNewRepuesto : repuestosNew) {
                if (!repuestosOld.contains(repuestosNewRepuesto)) {
                    Taller oldUnTallerOfRepuestosNewRepuesto = repuestosNewRepuesto.getUnTaller();
                    repuestosNewRepuesto.setUnTaller(taller);
                    repuestosNewRepuesto = em.merge(repuestosNewRepuesto);
                    if (oldUnTallerOfRepuestosNewRepuesto != null && !oldUnTallerOfRepuestosNewRepuesto.equals(taller)) {
                        oldUnTallerOfRepuestosNewRepuesto.getRepuestos().remove(repuestosNewRepuesto);
                        oldUnTallerOfRepuestosNewRepuesto = em.merge(oldUnTallerOfRepuestosNewRepuesto);
                    }
                }
            }
            for (Turno turnosOldTurno : turnosOld) {
                if (!turnosNew.contains(turnosOldTurno)) {
                    turnosOldTurno.setUnTaller(null);
                    turnosOldTurno = em.merge(turnosOldTurno);
                }
            }
            for (Turno turnosNewTurno : turnosNew) {
                if (!turnosOld.contains(turnosNewTurno)) {
                    Taller oldUnTallerOfTurnosNewTurno = turnosNewTurno.getUnTaller();
                    turnosNewTurno.setUnTaller(taller);
                    turnosNewTurno = em.merge(turnosNewTurno);
                    if (oldUnTallerOfTurnosNewTurno != null && !oldUnTallerOfTurnosNewTurno.equals(taller)) {
                        oldUnTallerOfTurnosNewTurno.getTurnos().remove(turnosNewTurno);
                        oldUnTallerOfTurnosNewTurno = em.merge(oldUnTallerOfTurnosNewTurno);
                    }
                }
            }
            for (ReparacionEnEjecucion reparacionesEnEjecucionOldReparacionEnEjecucion : reparacionesEnEjecucionOld) {
                if (!reparacionesEnEjecucionNew.contains(reparacionesEnEjecucionOldReparacionEnEjecucion)) {
                    reparacionesEnEjecucionOldReparacionEnEjecucion.setUnTaller(null);
                    reparacionesEnEjecucionOldReparacionEnEjecucion = em.merge(reparacionesEnEjecucionOldReparacionEnEjecucion);
                }
            }
            for (ReparacionEnEjecucion reparacionesEnEjecucionNewReparacionEnEjecucion : reparacionesEnEjecucionNew) {
                if (!reparacionesEnEjecucionOld.contains(reparacionesEnEjecucionNewReparacionEnEjecucion)) {
                    Taller oldUnTallerOfReparacionesEnEjecucionNewReparacionEnEjecucion = reparacionesEnEjecucionNewReparacionEnEjecucion.getUnTaller();
                    reparacionesEnEjecucionNewReparacionEnEjecucion.setUnTaller(taller);
                    reparacionesEnEjecucionNewReparacionEnEjecucion = em.merge(reparacionesEnEjecucionNewReparacionEnEjecucion);
                    if (oldUnTallerOfReparacionesEnEjecucionNewReparacionEnEjecucion != null && !oldUnTallerOfReparacionesEnEjecucionNewReparacionEnEjecucion.equals(taller)) {
                        oldUnTallerOfReparacionesEnEjecucionNewReparacionEnEjecucion.getReparacionesEnEjecucion().remove(reparacionesEnEjecucionNewReparacionEnEjecucion);
                        oldUnTallerOfReparacionesEnEjecucionNewReparacionEnEjecucion = em.merge(oldUnTallerOfReparacionesEnEjecucionNewReparacionEnEjecucion);
                    }
                }
            }
            for (DiaLaboral diasLaborablesOldDiaLaboral : diasLaborablesOld) {
                if (!diasLaborablesNew.contains(diasLaborablesOldDiaLaboral)) {
                    diasLaborablesOldDiaLaboral.setUnTaller(null);
                    diasLaborablesOldDiaLaboral = em.merge(diasLaborablesOldDiaLaboral);
                }
            }
            for (DiaLaboral diasLaborablesNewDiaLaboral : diasLaborablesNew) {
                if (!diasLaborablesOld.contains(diasLaborablesNewDiaLaboral)) {
                    Taller oldUnTallerOfDiasLaborablesNewDiaLaboral = diasLaborablesNewDiaLaboral.getUnTaller();
                    diasLaborablesNewDiaLaboral.setUnTaller(taller);
                    diasLaborablesNewDiaLaboral = em.merge(diasLaborablesNewDiaLaboral);
                    if (oldUnTallerOfDiasLaborablesNewDiaLaboral != null && !oldUnTallerOfDiasLaborablesNewDiaLaboral.equals(taller)) {
                        oldUnTallerOfDiasLaborablesNewDiaLaboral.getDiasLaborables().remove(diasLaborablesNewDiaLaboral);
                        oldUnTallerOfDiasLaborablesNewDiaLaboral = em.merge(oldUnTallerOfDiasLaborablesNewDiaLaboral);
                    }
                }
            }
            for (Proveedor proveedoresOldProveedor : proveedoresOld) {
                if (!proveedoresNew.contains(proveedoresOldProveedor)) {
                    proveedoresOldProveedor.setUnTaller(null);
                    proveedoresOldProveedor = em.merge(proveedoresOldProveedor);
                }
            }
            for (Proveedor proveedoresNewProveedor : proveedoresNew) {
                if (!proveedoresOld.contains(proveedoresNewProveedor)) {
                    Taller oldUnTallerOfProveedoresNewProveedor = proveedoresNewProveedor.getUnTaller();
                    proveedoresNewProveedor.setUnTaller(taller);
                    proveedoresNewProveedor = em.merge(proveedoresNewProveedor);
                    if (oldUnTallerOfProveedoresNewProveedor != null && !oldUnTallerOfProveedoresNewProveedor.equals(taller)) {
                        oldUnTallerOfProveedoresNewProveedor.getProveedores().remove(proveedoresNewProveedor);
                        oldUnTallerOfProveedoresNewProveedor = em.merge(oldUnTallerOfProveedoresNewProveedor);
                    }
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                int id = taller.getNroTaller();
                if (findTaller(id) == null) {
                    throw new NonexistentEntityException("The taller with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(int id) throws NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Taller taller;
            try {
                taller = em.getReference(Taller.class, id);
                taller.getNroTaller();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The taller with id " + id + " no longer exists.", enfe);
            }
            List<Empleado> empleados = taller.getEmpleados();
            for (Empleado empleadosEmpleado : empleados) {
                empleadosEmpleado.setUnTaller(null);
                empleadosEmpleado = em.merge(empleadosEmpleado);
            }
            Set<Repuesto> repuestos = taller.getRepuestos();
            for (Repuesto repuestosRepuesto : repuestos) {
                repuestosRepuesto.setUnTaller(null);
                repuestosRepuesto = em.merge(repuestosRepuesto);
            }
            List<Turno> turnos = taller.getTurnos();
            for (Turno turnosTurno : turnos) {
                turnosTurno.setUnTaller(null);
                turnosTurno = em.merge(turnosTurno);
            }
            List<ReparacionEnEjecucion> reparacionesEnEjecucion = taller.getReparacionesEnEjecucion();
            for (ReparacionEnEjecucion reparacionesEnEjecucionReparacionEnEjecucion : reparacionesEnEjecucion) {
                reparacionesEnEjecucionReparacionEnEjecucion.setUnTaller(null);
                reparacionesEnEjecucionReparacionEnEjecucion = em.merge(reparacionesEnEjecucionReparacionEnEjecucion);
            }
            List<DiaLaboral> diasLaborables = taller.getDiasLaborables();
            for (DiaLaboral diasLaborablesDiaLaboral : diasLaborables) {
                diasLaborablesDiaLaboral.setUnTaller(null);
                diasLaborablesDiaLaboral = em.merge(diasLaborablesDiaLaboral);
            }
            List<Proveedor> proveedores = taller.getProveedores();
            for (Proveedor proveedoresProveedor : proveedores) {
                proveedoresProveedor.setUnTaller(null);
                proveedoresProveedor = em.merge(proveedoresProveedor);
            }
            em.remove(taller);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<Taller> findTallerEntities() {
        return findTallerEntities(true, -1, -1);
    }

    public List<Taller> findTallerEntities(int maxResults, int firstResult) {
        return findTallerEntities(false, maxResults, firstResult);
    }

    private List<Taller> findTallerEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            cq.select(cq.from(Taller.class));
            Query q = em.createQuery(cq);
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public Taller findTaller(int id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(Taller.class, id);
        } finally {
            em.close();
        }
    }

    public int getTallerCount() {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            Root<Taller> rt = cq.from(Taller.class);
            cq.select(em.getCriteriaBuilder().count(rt));
            Query q = em.createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }
    
}
